C# 操作 JSON

不通过实体直接读取对象

直接读取（无需经过实体类）方法如下所示：

/// <summary>
/// 读取JSON文件
/// </summary>
/// <param name="key">JSON文件中的key值</param>
/// <returns>JSON文件中的value值</returns>
public static string Readjson(string key)
{
    string jsonfile = @"D:\testJson.json";//JSON文件路径
    using (System.IO.StreamReader file = System.IO.File.OpenText(jsonfile))
    {
        using (JsonTextReader reader = new JsonTextReader(file))
        {
            JObject o = (JObject)JToken.ReadFrom(reader);
            var value = o[key].ToString();
            return value;
        }
    }
}

注意这个 JsonTextReader 是一个外部包（Newtonsoft.Json），可以通过 NuGet 包管理器自动下载

// 注意在 C# 8.0 版本可以直接这样写
using var file = System.IO.File.OpenText(jsonfile);

或者直接：

string json = "{\"name\":\"alsritter\" }"
JObject o = JObject.Parse(json);
string name = o["name"];

参考资料 using 语句（C# 参考）

不通过实体直接读取数组

这里是 Unity 的例子：关键就是这个 JArray 对象，要区别上面的 JObject 对象

/// <summary>
/// 解析JSON，获取所有面板的路径信息
/// </summary>
private static void ParseUIPanelTypeJsonData(IDictionary<UIPanelType, string> panelPathDict)
{
    var ta = Resources.Load<TextAsset>("UIPanelType");
    //JsonData jsonDataArray = JsonMapper.ToObject(ta.text);
    var array = JArray.Parse(ta.text);
    foreach (var item in array)
    {
        var panelType = (UIPanelType)Enum.Parse(typeof(UIPanelType), item["panelType"].ToString());
        var path = item["path"].ToString();
        panelPathDict.Add(panelType, path);
    }
}

根据 JSON 文件生成实体类

一般都是将 JSON 映射到视图类里面来方便操作，这里推荐使用这个 JSON to C# Converter 网站的工具自动转

{
  "version": 1,
  "tiles": [
    {
      "image": "这里是地址",
      "tilename": "tile01",
      "effects": [
        {
          "fullname": "MyTestClassNamespace.TestClass01",
          "version": 1,
          "parameters": [
            {
              "type": "System.Int32",
              "name": "age",
              "value": 18
            },
            {
              "type": "System.String",
              "name": "name",
              "value": 18
            }
          ]
        }
      ]
    },
    {
      "image": "这里是地址2",
      "tilename": "tile02",
      "effects": [
        {
          "fullname": "MyTestClassNamespace.TestClass02",
          "version": 1,
          "parameters": [
            {
              "type": "System.Boolean",
              "name": "flag",
              "value": true
            },
            {
              "type": "System.Boolean",
              "name": "test",
              "value": false
            }
          ]
        }
      ]
    }
  ]
}

转成的实体类为：

    public class TileInfo
    {
        [JsonProperty("version")]
        public int Version { get;set; }

        [JsonProperty("tiles")]
        public List<TilesItem> Tiles { get;set; }
    }

    public class TilesItem
    {
        [JsonProperty("image")]
        public string Image { get;set; }

        [JsonProperty("tilename")]
        public string Tilename { get;set; }

        [JsonProperty("effects")]
        public List<EffectsItem> Effects { get;set; }
    }

    public class EffectsItem
    {
        [JsonProperty("fullname")]
        public string Fullname { get;set; }

        [JsonProperty("version")]
        public int Version { get;set; }

        [JsonProperty("parameters")]
        public List<ParametersItem> Parameters { get;set; }
    }

    public class ParametersItem
    {
        [JsonProperty("type")]
        public string Type { get;set; }

        [JsonProperty("name")]
        public string Name { get;set; }

// 注意，这里可能为各种基本类型，所以设为 object
        [JsonProperty("value")]
        public object Value { get;set; } 
    }

使用 Newtonsoft.Json 序列化数据

//示例
private void Button_Click(object sender, RoutedEventArgs e)
{
    Student stu = new Student() { Name = "小明",Age = 18};
    string json = JsonConvert.SerializeObject(stu);//序列化
    Student stu2 = JsonConvert.DeserializeObject<Student>(json);//反序列化
 
    List<Student> stuList = new List<Student>();
    stuList.Add(new Student() { Name = "小明", Age = 18 });
    stuList.Add(new Student() { Name = "小红", Age = 19 });
    string json1 = JsonConvert.SerializeObject(stuList);
    List<Student> stuList2 = JsonConvert.DeserializeObject<List<Student>>(json1);
 
    SchoolData sch = new SchoolData();
    sch.Name = "xx初中";
    sch.StudentList = new List<Student>();
    sch.StudentList.Add(new Student() { Name = "小明", Age = 18 });
    sch.StudentList.Add(new Student() { Name = "小红", Age = 19 });
    string json2 = JsonConvert.SerializeObject(sch);
    SchoolData sch2 = JsonConvert.DeserializeObject<SchoolData>(json2);
 
 
    //测试我当前版本.net 4.6  Newtonsoft.Json 12.0.0.0   
    //可以把小写字段名称或者同名但是大小写不一样  自动识别转换
    string strJson = "{\"name\":\"小明\",\"age\":18}";
    Student s1 = JsonConvert.DeserializeObject<Student>(strJson);
    string strJson = "{\"NAME\":\"小明\",\"AGE\":18}";
    Student s1 = JsonConvert.DeserializeObject<Student>(strJson);
}

使用 Newtonsoft.Json 反序列化数据

public static void LoadingJsonData(string path)
{
    using (var file = System.IO.File.OpenText(path))
    {
        using (var reader = new JsonTextReader(file))
        {
            JObject o = (JObject)JToken.ReadFrom(reader);
            // 可以在序列化之前先检查文件版本
            var version = o.GetValue("version")?.ToObject<int>();
            if (version != 1)
            {
                Console.WriteLine("当前文件版本不对");
                return;
            }

            Console.WriteLine(o.ToString());
            TileInfo info = JsonConvert.DeserializeObject<TileInfo>(o.ToString());
        }
    }
}

反序列化数组

和上面的方式基本相同，只不过先通过 JArray 取得数组先再反序列化

var array = JArray.Parse(result);
foreach (var item in array)
{
    mapInfos.Add( JsonConvert.DeserializeObject<GameMapInfoDTO>(item.ToString()));
}

忽略某些属性

实体中有些属性不需要序列化返回，可以使用该特性。首先介绍 Json.Net 序列化的模式：OptOut 和 OptIn

*OptOut 默认值，类中所有公有成员会被序列化，如果不想被序列化，可以用特性 JsonIgnore*
*OptIn 默认情况下，所有的成员不会被序列化，类中的成员只有标有特性 JsonProperty 的才会被序列化，当类的成员很多，但客户端仅仅需要一部分数据时，很有用*

仅需要姓名属性

[JsonObject(MemberSerialization.OptIn)]
public class Person
{
    public int Age { get; set; }
  
    [JsonProperty]
    public string Name { get; set; }
    public string Sex { get; set; }
    public bool IsMarry { get; set; }
    public DateTime Birthday { get; set; }
}

不需要是否结婚属性

[JsonObject(MemberSerialization.OptOut)]
public class Person
{
    public int Age { get; set; }
    public string Name { get; set; }
    public string Sex { get; set; }

    [JsonIgnore]
    public bool IsMarry { get; set; }
    public DateTime Birthday { get; set; }
}

默认值处理

序列化时想忽略默认值属性可以通过 JsonSerializerSettings.DefaultValueHandling 来确定，该值为枚举值

枚举	作用
DefaultValueHandling.Ignore	序列化和反序列化时，忽略默认值
DefaultValueHandling.Include	序列化和反序列化时，包含默认值

[DefaultValue(10)]
public int Age { get; set; }

Person p = new Person { Age = 10, Name = "张三丰", Sex = "男", IsMarry = false, Birthday = new DateTime(1991, 1, 2)};

JsonSerializerSettings jsetting = new JsonSerializerSettings();

jsetting.DefaultValueHandling = DefaultValueHandling.Ignore;

Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

最终结果如下：

空值的处理

序列化时需要忽略值为 NULL 的属性，可以通过 JsonSerializerSettings.NullValueHandling 来确定，另外通过 JsonSerializerSettings 设置属性是对序列化过程中所有属性生效的，想单独对某一个属性生效可以使用 JsonProperty，下面将分别展示两个方式

JsonSerializerSettings

Person p = new Person { room=null,Age = 10, Name = "张三丰", Sex = "男", IsMarry = false, Birthday = new DateTime(1991, 1, 2) };

JsonSerializerSettings jsetting = new JsonSerializerSettings();

jsetting.NullValueHandling = NullValueHandling.Ignore;

Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

JsonProperty

通过 JsonProperty 属性设置的方法，可以实现某一属性特别处理的需求，如默认值处理，空值处理，自定义属性名处理，格式化处理。上面空值处理实现

[JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
public Room room { get; set; }

支持非公共成员

序列化时默认都是处理公共成员，如果需要处理非公共成员，就要在该成员上加特性 "JsonProperty"

[JsonProperty]
private int Height { get; set; }

日期处理

对于 Datetime 类型日期的格式化就比较麻烦了，系统自带的会格式化成 iso 日期标准

但是实际使用过程中大多数使用的可能是 yyyy-MM-dd 或者 yyyy-MM-dd HH:mm:ss 两种格式的日期，解决办法是可以将 DateTime 类型改成 string 类型自己格式化好，然后在序列化。如果不想修改代码，可以采用下面方案实现。

Json.Net 提供了 IsoDateTimeConverter 日期转换这个类，可以通过 JsnConverter 实现相应的日期转换

[JsonConverter(typeof(IsoDateTimeConverter))]
public DateTime Birthday { get; set; }

但是 IsoDateTimeConverter 日期格式不是我们想要的，我们可以继承该类实现自己的日期

public class ChinaDateTimeConverter : DateTimeConverterBase
{
    private static IsoDateTimeConverter dtConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd" };

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        return dtConverter.ReadJson(reader, objectType, existingValue, serializer);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        dtConverter.WriteJson(writer, value, serializer);
    }
}

自己实现了一个 yyyy-MM-dd 格式化转换类，可以看到只是初始化 IsoDateTimeConverter 时给的日期格式为 yyyy-MM-dd 即可，下面看下效果

[JsonConverter(typeof(ChinaDateTimeConverter))]
public DateTime Birthday { get; set; }

可以根据自己需求实现不同的转换类

自定义序列化的字段名称

实体中定义的属性名可能不是自己想要的名称，但是又不能更改实体定义，这个时候可以自定义序列化字段名称。

[JsonProperty(PropertyName = "CName")]
public string Name { get; set; }

动态决定属性是否序列化

根据某些场景，可能 A场景输出 A，B，C三个属性，B场景输出 E，F属性。

虽然实际中不一定存在这种需求，但是 json.net 依然可以支持该特性。

继承默认的 DefaultContractResolver 类，传入需要输出的属性

重写修改了一下，大多数情况下应该是要排除的字段少于要保留的字段，为了方便书写这里修改了构造函数加入 retain 表示 props 是需要保留的字段还是要排除的字段

public class LimitPropsContractResolver : DefaultContractResolver
{
    string[] props = null;
    bool retain;

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="props">传入的属性数组</param>
    /// <param name="retain">true:表示props是需要保留的字段  false：表示props是要排除的字段</param>
    public LimitPropsContractResolver(string[] props, bool retain=true)
    {
        //指定要序列化属性的清单
        this.props = props;   
        this.retain = retain;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> list = base.CreateProperties(type, memberSerialization);
        //只保留清单有列出的属性
        return list.Where(p => {
            if (retain)
            {
                return props.Contains(p.PropertyName);
            }
            else
            {
                return !props.Contains(p.PropertyName);
            }      
        }).ToList();
    }

实体类如下

public int Age { get; set; }

[JsonIgnore]
public bool IsMarry { get; set; }

public string Sex { get; set; }

使用方式：

JsonSerializerSettings jsetting=new JsonSerializerSettings();
jsetting.ContractResolver = new LimitPropsContractResolver(new string[] { "Age", "IsMarry" });
Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));

使用自定义的解析类，只输出 "Age", "IsMarry" 两个属性，看下最终结果，只输出了 Age 属性，为什么 IsMarry 属性没有输出呢，因为标注了 JsonIgnore

枚举值的自定义格式化问题

默认情况下对于实体里面的枚举类型系统是格式化成改枚举对应的整型数值，那如果需要格式化成枚举对应的字符怎么处理呢？ Newtonsoft.Json 也帮我们想到了这点，下面看实例

public enum NotifyType
{
    /// <summary>
    /// Emil发送
    /// </summary>
    Mail = 0,
    /// <summary>
    /// 短信发送
    /// </summary>
    SMS = 1
}

public class TestEnmu
{
    /// <summary>
    /// 消息发送类型
    /// </summary>
    public NotifyType Type { get; set; }
}

JsonConvert.SerializeObject(new TestEnmu());

输出结果：

现在改造一下，输出 "Type":"Mail"

public class TestEnmu
{
    /// <summary>
    /// 消息发送类型
    /// </summary>
    [JsonConverter(typeof(StringEnumConverter))]
    public NotifyType Type { get; set; }
}

其它的都不变，在 Type 属性上加上了 JsonConverter(typeof(StringEnumConverter)) 表示将枚举值转换成对应的字符串，而 StringEnumConverter 是 Newtonsoft.Json 内置的转换类型，最终输出结果

自定义类型转换

默认情况下对于实体里面的 Boolean 系统是格式化成 true 或者 false，对于 true 转成 "是"，false 转成"否" 这种需求改怎么实现了？

我们可以自定义类型转换实现该需求，下面看实例：

public class BoolConvert : JsonConverter
{
    private string[] arrBString { get; set; }

    public BoolConvert()
    {
        arrBString = "是,否".Split(',');
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="BooleanString">将bool值转换成的字符串值</param>
    public BoolConvert(string BooleanString)
    {
        if (string.IsNullOrEmpty(BooleanString))
        {
            throw new ArgumentNullException();
        }
        arrBString = BooleanString.Split(',');
        if (arrBString.Length != 2)
        {
            throw new ArgumentException("BooleanString格式不符合规定");
        }
    }


    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        bool isNullable = IsNullableType(objectType);
        Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;

        if (reader.TokenType == JsonToken.Null)
        {
            if (!IsNullableType(objectType))
            {
                throw new Exception(string.Format("不能转换null value to {0}.", objectType));
            }

            return null;
        }

        try
        {
            if (reader.TokenType == JsonToken.String)
            {
                string boolText = reader.Value.ToString();
                if (boolText.Equals(arrBString[0], StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }
                else if (boolText.Equals(arrBString[1], StringComparison.OrdinalIgnoreCase))
                {
                    return false;
                }
            }

            if (reader.TokenType == JsonToken.Integer)
            {
                //数值
                return Convert.ToInt32(reader.Value) == 1;
            }
        }
        catch (Exception ex)
        {
            throw new Exception(string.Format("Error converting value {0} to type '{1}'", reader.Value, objectType));
        }
        throw new Exception(string.Format("Unexpected token {0} when parsing enum", reader.TokenType));
    }

    /// <summary>
    /// 判断是否为Bool类型
    /// </summary>
    /// <param name="objectType">类型</param>
    /// <returns>为bool类型则可以进行转换</returns>
    public override bool CanConvert(Type objectType)
    {
        return true;
    }


    public bool IsNullableType(Type t)
    {
        if (t == null)
        {
            throw new ArgumentNullException("t");
        }
        return (t.BaseType.FullName=="System.ValueType" && t.GetGenericTypeDefinition() == typeof(Nullable<>));
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value == null)
        {
            writer.WriteNull();
            return;
        }

        bool bValue = (bool)value;

        if (bValue)
        {
            writer.WriteValue(arrBString[0]);
        }
        else
        {
            writer.WriteValue(arrBString[1]);
        }
    }
}

自定义了 BoolConvert 类型，继承自 JsonConverter。构造函数参数 BooleanString 可以让我们自定义将 true false 转换成相应字符串。下面看实体里面怎么使用这个自定义转换类型

public class Person
{
    [JsonConverter(typeof(BoolConvert))]
    public bool IsMarry { get; set; }
}

相应的有什么个性化的转换需求，都可以使用自定义转换类型的方式实现。

全局序列化设置

文章开头提出了 Null 值字段怎么不返回的问题，相应的在高级用法也给出了相应的解决方案使用

jsetting.NullValueHandling = NullValueHandling.Ignore;

来设置不返回空值。这样有个麻烦的地方，每个不想返回空值的序列化都需设置一下。可以对序列化设置一些默认值方式么？

Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();

JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() =>
{　 // 日期类型默认格式化处理
　　setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
   setting.DateFormatString = "yyyy-MM-dd HH:mm:ss";
　　// 空值处理
   setting.NullValueHandling = NullValueHandling.Ignore;      //高级用法九中的 Bool 类型转换 设置
   setting.Converters.Add(new BoolConvert("是,否"));
   return setting;
});

这样设置以后，以后使用序列化的地方就不需要单独设置了

Int32 to Int64 报错的问题

如果使用 object 来接收类型（可能有各种类型）

[JsonProperty("value")]
public object Value { get;set; } // 因为这里可能为各种基本类型

默认数值类型是转换成 Int64，而不是 Int32

Int64 对应的是 long 类型 Int32 对应的是 int 类型

这种时候可以编写一个转换器，把 Int64 转成 int32

/// <summary>
/// 用来解决，转换实体 Int64 的问题
/// </summary>
public class JsonInt32Converter : JsonConverter
{
    // 判断是否是可以转换（true）
    public override bool CanConvert(Type objectType)
    {
      // 其实可以直接返回 return true; 但是这里也可以用来做类型控制
        return objectType == typeof(int) ||
               objectType == typeof(long) ||
               objectType == typeof(object); // 这里可以改成 string 表示只支持数值和字符型能转换
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }

    // 把 long 类型转成 int 类型，其它的直接放行
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        return reader.Value is long ? Convert.ToInt32(reader.Value) : reader.Value;
    }
}

在实体类使用这个转换器

[JsonProperty("value")]
[JsonConverter(typeof(JsonInt32Converter))]
public object Value { get;set; } // 因为这里可能为各种基本类型

Reference

参考资料 Newtonsoft.Json 官方文档
参考资料 C# JSON
参考资料 C# 读取Json文件
参考资料 Newtonsoft.Json 序列化和反序列化以及时间格式 2 高级使用

不通过实体直接读取对象​

不通过实体直接读取数组​

根据 JSON 文件生成实体类​

使用 Newtonsoft.Json 序列化数据​

使用 Newtonsoft.Json 反序列化数据​

反序列化数组​

忽略某些属性​

默认值处理​

空值的处理​

JsonSerializerSettings​

JsonProperty​

支持非公共成员​

日期处理​

自定义序列化的字段名称​

动态决定属性是否序列化​

枚举值的自定义格式化问题​

自定义类型转换​

全局序列化设置​

Int32 to Int64 报错的问题​

Reference​